"ui"

let screenWidth = device.width;
// 获取屏幕高度（px）
let screenHeight = device.height;

let analyseSartY = 160;
let analyseEndY = Infinity;
let analyseThreshold = 100;
// 配置 API 信息（请替换为实际接口地址和密钥）
const API_URL = "https://ark.cn-beijing.volces.com/api/v3/chat/completions"; // 豆包对话接口地址
const API_KEY = "d170bd1c-22fd-48dc-a0b0-5f653e7f9d6b"; // 替换为你的实际 API Key
const MODEL = "doubao-1-5-pro-32k-250115"; // 固定使用的模型
let currentMsgHistory = []
// 第一步：补充 startsWith 兼容方法（最顶部）
if (!String.prototype.startsWith) {
  String.prototype.startsWith = function (search, pos) {
    pos = pos || 0;
    return this.substring(pos, pos + search.length) === search;
  };
}

if (!images.requestScreenCapture()) {  console.log("请在弹出的窗口中允许截图权限");  exit();}else{}

//2. 测试截图
threads.start(function() {
  let img = images.captureScreen();
  if (img) {
      toast("截图成功");
      img.recycle(); // 释放内存
  } else {
      toast("截图失败");
  }
});
// ===== 配置区 =====
const config = {
  doubaoApiKey: API_KEY, // 替换为豆包API密钥
  floatBtnSize: 40,             // 悬浮按钮大小
  ocrAccuracy: 0.8,             // OCR识别阈值
  replyCount: 3,                 // 生成回复数量
  replyType: "高情商，幽默，贱贱的",
  replyCenter: ""
};

// ===== 全局变量 =====
let floatWindow = null;       // 悬浮窗实例
let replyWindow = null;       // 回复展示窗
let isListening = false;      // 监听状态

// ===== 工具函数 =====
/**
 * 初始化悬浮按钮
 */
function initFloatButton() {
  // 检查悬浮窗权限
  if (!floaty.checkPermission()) {
    toast("本脚本需要悬浮窗权限来显示悬浮窗，请在随后的界面中允许并重新运行本脚本。");
    floaty.requestPermission();
    exit();
  }

  if (floatWindow) {
    return;
  }



  // 创建悬浮窗XML结构
  floatWindow = floaty.window(`
  <frame>
  
   
    <img 
      id="floatBtn" 
      w="${config.floatBtnSize}" 
      h="${config.floatBtnSize}" 
      src="http://39.105.231.80:9900/keji.png"
    />

    <img 
      id="thinking" 
      w="${config.floatBtnSize}" 
      h="${config.floatBtnSize}" 
      visibility="gone"
      src="http://39.105.231.80:9900/loading.png"
    />
  </frame>
`);


  // 禁用窗口调整功能，保持界面整洁
  //  floatWindow.setAdjustEnabled(true);
  // 设置悬浮窗关闭时退出脚本
  floatWindow.exitOnClose();

  // 空定时器保持脚本运行，防止悬浮窗被关闭
  setInterval(() => { }, 1000);

  // 获取悬浮窗内的frame组件
  let floatBtn = floatWindow.floatBtn;

  // 初始位置
  let x = 50, y = 200;
  floatWindow.setPosition(x, y);

  // 拖动变量
  let lastX, lastY;

  // 触摸事件监听（兼容写法）
  floatBtn.setOnTouchListener(function (view, event) {
    switch (event.getAction()) {
      case event.ACTION_DOWN:
        lastX = event.getRawX();
        lastY = event.getRawY();
        return true;
      case event.ACTION_MOVE:
        floatWindow.setPosition(
          floatWindow.getX() + (event.getRawX() - lastX),
          floatWindow.getY() + (event.getRawY() - lastY)
        );
        lastX = event.getRawX();
        lastY = event.getRawY();
        return true;
      case event.ACTION_UP:
        if (event.getEventTime() - event.getDownTime() < 300) {
          onFloatButtonClick();
        }
        return true;
    }
    return false;
  });
}
function onFloatButtonClick() {

  if (floatWindow.thinking.getVisibility() === 0) { // 0表示VISIBLE
    return; // 如果进度条正在显示，则忽略点击
  }
  if (replyWindow) {
    replyWindow.close();
    replyWindow = null;
  }

  // 显示进度条
  floatWindow.thinking.setVisibility(0); // 0表示VISIBLE
  floatWindow.floatBtn.setVisibility(8); // 0表示VISIBLE

  //floatWindow.floatBtn.setEnabled(false); // 禁用按钮点击



  mycaptureScreen().then(imgPath => {
    return ocrImage(imgPath);
  }).then(chatText => {
    return generateAIReply(chatText);
  }).then(replies => {
    showReplyWindow(replies);
  }).catch(err => {
    toast("处理失败: " + err.message);
    console.error(err);
  }).finally(() => {
    // 无论成功失败，都隐藏进度条并启用按钮
    ui.run(() => {
      floatWindow.thinking.setVisibility(8); // 0表示VISIBLE
      floatWindow.floatBtn.setVisibility(0); // 0表
    })


  });

}
/**
 * 截图当前屏幕
 */
function mycaptureScreen() {
  return new Promise((resolve, reject) => {
    // 生成截图路径
    let imgName = "screenshot_" + new Date().getTime() + ".png";
    let imgPath = files.path(imgName); // 获取完整路径

    // 手动提取目录路径
    let pathParts = imgPath.split("/");
    let dirPath = pathParts.slice(0, pathParts.length - 1).join("/");

    // 使用 Java API 创建目录（兼容性更好）
    try {
      let file = new java.io.File(dirPath);
      if (!file.exists()) {
        let success = file.mkdirs();
        if (!success) {
          reject(new Error("无法创建目录：" + dirPath));
          return;
        }
      }
    } catch (e) {
      reject(new Error("创建目录失败：" + e));
      return;
    }

    threads.start(function () {
      try {
        if (images.captureScreen(imgPath)) {
          resolve(imgPath);
        } else {
          files.remove(imgPath);
          reject(new Error("截图失败，请检查权限"));
        }
      } catch (e) {
        files.remove(imgPath);
        reject(e);
      }
    });
  });
}

/**
 * OCR识别图片文字
 * 注：实际使用需集成OCR服务，此处为简化示例
 */
function ocrImage(imgPath) {
  return new Promise((resolve, reject) => {
    // 这里简化处理，实际项目需集成百度OCR或其他服务
    // 示例：提取图片中的文本内容
    let img = images.read(imgPath)
    let result = gmlkit.ocr(img, "zh");
    resolve(extractChatMessages(result, screenWidth, analyseSartY, analyseEndY, analyseThreshold))

    //删掉截图
    // img.recycle()
    // files.remove(imgPath);
    // setTimeout(() => {
    //   // 模拟OCR识别结果
    //   const mockChat = "对方: 你好，最近在忙什么？\n我: 没什么特别的，你呢？\n对方: 我在学习AutoX.js开发";
    //   resolve(mockChat);
    // }, 1500);
  });



}
/**
 * 从 OCR 结果提取聊天记录，区分对方消息和我的消息
 * @param {GoogleMLKitOcrResult} ocrResult - OCR 识别结果
 * @param {number} screenWidth - 屏幕宽度（默认 720px）
 * @param {number} [topY=0] - 只分析此 Y 值以上的内容
 * @param {number} [bottomY=Infinity] - 只分析此 Y 值以下的内容
 * @param {number} [threshold=50] - 中心点判定阈值（像素）
 * @returns {Array} [{user: "other"|"me", msg: "内容"}, ...]
 */
function extractChatMessages(ocrResult, screenWidth, topY, bottomY, threshold) {
  const messages = [];
  const screenCenter = screenWidth / 2;

  // 递归收集所有文本节点
  function collectNodes(node, nodes) {
    if (!nodes) {
      nodes = [];
    }
    if (node.children) {
      node.children.forEach(child => collectNodes(child, nodes));
    } else if (node.text && node.text.trim() && node.bounds) {
      nodes.push({
        text: node.text.trim(),
        bounds: node.bounds,
        confidence: node.confidence,
        language: node.language
      });
    }
    return nodes;
  }

  const nodes = collectNodes(ocrResult)
    // 过滤 Y 轴范围
    .filter(node => {
      const centerY = (node.bounds.top + node.bounds.bottom) / 2;
      return centerY >= topY && centerY <= bottomY;
    })
    // 按 Y 轴位置排序（从上到下）
    .sort((a, b) => a.bounds.top - b.bounds.top);

  // 处理每条消息
  nodes.forEach(node => {
    const { text, bounds, confidence, language } = node;
    const centerX = (bounds.left + bounds.right) / 2;

    // 规则1：过滤居中内容（时间戳、按钮等）
    if (Math.abs(centerX - screenCenter) <= threshold) {
      return;
    }

    // 规则2：过滤时间戳（如 3:40、Ff3:25）
    if (text.match(/^\d{1,2}:\d{2}$/) || text.match(/Ff\d{1,2}:\d{2}/)) {
      return;
    }

    // 规则3：过滤无意义符号（如 TEL、<2、|发送）
    if (text.match(/^[<>|TELFf]+$/) || text.length === 1) {
      return;
    }

    // 规则3：过滤无意义符号（如 TEL、<2、|发送）
    if (text == '发送' || text == '搜索') {
      return;
    }

    // 规则4：区分对方消息（左）和我的消息（右）
    messages.push({
      user: centerX < screenCenter - threshold ? "other" : "me",
      msg: text
    });
  });
  currentMsgHistory = messages
  return messages;
}


function formatChatWithQuotes(history) {
  let result = '';
  history.forEach((item, index) => {
    // 根据角色选择前缀（ta/我），并添加引号
    const prefix = item.user === 'other' ? 'ta说：“' : '我说：“';
    // 拼接内容（结尾添加闭合引号）
    const content = `${prefix}${item.msg}”`;
    // 最后一条不加逗号，其他加逗号分隔
    result += content + (index === history.length - 1 ? '' : '，');
  });
  return result;
}
/**
 * 调用豆包AI生成回复
 */
function generateAIReply(chatHistory) {
  return new Promise((resolve, reject) => {
    if (!config.doubaoApiKey) {
      reject(new Error("请先配置豆包API密钥"));
      return;
    }

    // 构建API请求
    let replycenter = ""
    if (config.replyCenter) {
      replycenter = "接下来，我想回复" + config.replyCenter + "，"
    }
    //const prompt = `基于以下聊天历史，生成${config.replyCount}个${replycenter}${config.replyType}的回复，要求用####隔开,(聊天历史是截图后文字识别出的，所以你在生成回复前，智能判断一下哪些是真实的聊天内容，哪些不是。回复时只要答案，不要带着其他内容，也不要带着序号)，聊天记录如下：\n${JSON.stringify(chatHistory)}`;

    let chathistorystr = formatChatWithQuotes(chatHistory)
    const prompt = `基于以下聊天历史，${replycenter}请生成${config.replyCount}个${config.replyType}的回复，要求：用####隔开，回复时只保留答案，不要序号和其他内容，确保回复与聊天内容紧密相关，聊天历史是截图后文字识别出的。可能有识别错误，有多余的，识别一下去掉没用的，聊天记录如下：${chathistorystr}`;
    // // 实际项目需替换为真实API调用
    // setTimeout(() => {
    //   // 模拟AI回复
    //   const mockReplies = [
    //     "听起来很有趣！AutoX.js能做很多自动化任务呢",
    //     "我也在学习JavaScript，一起交流呀",
    //     "AutoX.js开发有遇到什么问题吗？"
    //   ];
    //   resolve(mockReplies);
    // }, 2000);

    chatWithDoubao(prompt, function (err, reply, usedModel) {
      if (err) {
        toastLog("错误：" + err);
        console.error("错误：", err);
      } else {
        console.log(`使用模型 ${usedModel} 回复：`, reply);
        let finalReply = reply.split("####")
        resolve(finalReply)
      }
    });
  });
}


function getRandomColor() {
  // 生成6位随机十六进制数
  const hexChars = '0123456789ABCDEF';
  let color = '#';
  for (let i = 0; i < 6; i++) {
    color += hexChars.charAt(Math.floor(Math.random() * hexChars.length));
  }
  return color;
}


/**
 * 显示回复窗口
 */
function showReplyWindow(replies) {
  replies = replies.filter(item => item && item.trim())
  // 1. 创建主窗口（半透明背景，文字保持清晰）
  replyWindow = floaty.window(
    `<vertical 
          id="replyWindowContent"
          bg="#CCFFFFFF"
          w="match_parent"
          h="auto" 
          padding="10" 
          radius="8"
      >
          <text 
              text="智能回复" 
              size="14" 
              color="#000000"
              margin="0 0 8 0"
              bold="true"
          />
          <linear>
              <text text="回复风格:" textColor="#454343" textSize="10sp"/>
              <button id="reply_type" text="${config.replyType}" style="Widget.AppCompat.Button.Borderless.Colored" w="auto" textSize="12sp"/>
          </linear>
          <linear>
              <text text="围绕主题:" textColor="#454343" textSize="10sp"/>
              <button id="reply_center" text="${config.replyCenter || '无主题'}" style="Widget.AppCompat.Button.Borderless.Colored" w="auto" textSize="12sp"/>
          </linear>
          <vertical id="replyContainer" w="match_parent" h="wrap_content">
              ${replies.map((reply, index) => (
      `
                    <card w="*" h="70" margin="10 5" cardCornerRadius="2dp"
                        cardElevation="1dp" gravity="center_vertical">
                        <vertical padding="18 8" h="auto">
                            <text id="reply_${index}" text="${reply}" textColor="#222222" textSize="12sp"/>
                        </vertical>
                        <View bg="${getRandomColor()}" h="*" w="10"/>
                    </card>
                    `
    ))
    }
          </vertical>

          <frame>
              <button 
                id="refresh" 
                text="换一批" 
                w="auto" 
                marginLeft="25"
                textColor="#FFFFFF"
              />
              <button 
                layout_gravity="right"
                marginRight="25"
                id="btnClose" 
                text="关闭" 
                style="Widget.AppCompat.Button.Colored" 
                w="auto"
              />
          </frame>
      </vertical>`
  );

// 修复回复风格按钮点击事件
replyWindow.reply_type.on("click", () => {
  // 确保整个操作在UI线程中执行
  ui.run(() => {
    replyWindow.replyWindowContent.setVisibility(8);
    // 使用带回调的输入框，避免线程阻塞
    dialogs.rawInput("请输入回复风格", config.replyType, (text) => {
      if (text && text.trim()) { // 确保输入有效
        config.replyType = text.trim();
        // 再次确认在UI线程中更新文本
        ui.run(() => {
          replyWindow.replyWindowContent.setVisibility(0);
          replyWindow.reply_type.setText(config.replyType);
        });
      }
    });
  });
});

// 修复围绕主题按钮点击事件
replyWindow.reply_center.on("click", () => {
  ui.run(() => {
    replyWindow.replyWindowContent.setVisibility(8);
    dialogs.rawInput("请输入围绕主题", config.replyCenter || "无主题", (text) => {
      if (text !== null) { // 允许清空主题（输入空值）
        config.replyCenter = text.trim() || "";
        ui.run(() => {
          replyWindow.replyWindowContent.setVisibility(0);
          replyWindow.reply_center.setText(config.replyCenter || "无主题");
        });
      }
    });
  });
});
  // 关闭按钮事件
  replyWindow.btnClose.on("click", () => {
    replyWindow.close();
    replyWindow = null
  });
  // 刷新按钮事件
  // 刷新按钮事件（修改后）
  replyWindow.refresh.on("click", () => {
    replyWindow.refresh.setText("思考中...");
    // 显示加载状态（可选，提升体验）
    if (floatWindow) {
      floatWindow.thinking.setVisibility(0);
      floatWindow.floatBtn.setVisibility(8);
    }

    generateAIReply(currentMsgHistory)
      .then(replies => {
        replyWindow.close();
        replyWindow = null;
        return replies
      })
      .then(replies => {
        showReplyWindow(replies);
      })
      .catch(err => {  // 添加错误捕获
        toast("刷新失败: " + err.message);
      })
      .finally(() => {  // 恢复加载状态
        if (floatWindow) {
          ui.run(() => {
            floatWindow.thinking.setVisibility(8);
            floatWindow.floatBtn.setVisibility(0);
          });
        }
      });
  });

  ui.run(() => {
    // 为每个回复按钮设置点击事件
    replies.forEach((reply, index) => {
      replyWindow[`reply_${index}`].on("click", () => {
        console.log("点击了回复：", reply);
        setClip(reply);
        toast("回复已复制");  // 恢复提示，提升用户体验
        replyWindow.close();
        replyWindow = null
      });
    });
  })
}



/**
 * 发送消息给豆包（简化版）
 * @param {string} message 用户消息
 * @param {function} callback 回调函数 (err, reply)
 */
function chatWithDoubao(message, callback) {
  const requestBody = {
    model: MODEL,
    messages: [{ role: "user", content: message }],
    temperature: 0.8
  };

  console.log(`使用模型 ${MODEL} 发送请求:`, message);

  http.postJson(API_URL, requestBody, {
    headers: {
      "Authorization": `Bearer ${API_KEY}`,
      "Content-Type": "application/json"
    }
  }, function (response, error) {
    if (error) {
      callback("请求失败: " + error.message, null);
      return;
    }

    try {
      const responseText = response.body.string();
      console.log("豆包响应内容:", responseText);

      const result = JSON.parse(responseText);
      if (response.statusCode === 200 && result.choices && result.choices[0].message) {
        callback(null, result.choices[0].message.content);
      } else {
        callback(`API错误: ${result.error && result.error.message || "未知错误"}`, null);
      }
    } catch (e) {
      callback("解析响应失败: " + e.message, null);
    }
  });
}

// ===== 主程序 =====
function main() {

  // 初始化悬浮按钮
  initFloatButton();
  toast("智能聊天助手已启动");

  // 监听返回键退出
  events.on("back_pressed", function () {
    if (replyWindow) {
      replyWindow.close();
      replyWindow = null;
      return true;
    }
    floatWindow.close();
    floatWindow = null
    engines.myEngine().forceStop();
    return true;
  });
}
// 启动主程序
main();